{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <center>手写数字分类识别入门体验</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 实现一个图片分类应用\n",
    "## 概述\n",
    "下面我们通过一个实际样例，带领大家体验MindSpore基础的功能，对于一般的用户而言，完成整个样例实践会持续20~30分钟。\n",
    "\n",
    "本例子会实现一个简单的图片分类的功能，整体流程如下：\n",
    "\n",
    "1. 处理需要的数据集，这里使用了MNIST数据集。\n",
    "\n",
    "2. 定义一个网络，这里我们使用LeNet网络。\n",
    "\n",
    "3. 自定义回调函数收集模型的损失值和精度值。\n",
    "\n",
    "4. 加载数据集并进行训练，训练完成后，查看结果及保存模型文件。\n",
    "\n",
    "5. 加载保存的模型，进行推理。\n",
    "\n",
    "6. 验证模型，加载测试数据集和训练后的模型，验证结果精度。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 本文档适用于CPU、GPU和Ascend环境。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练的数据集下载"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "直接执行下面代码，会自动进行训练集的下载与解压。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--2020-11-30 16:41:42--  https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/datasets/MNIST_Data.zip\n",
      "Resolving proxy-notebook.modelarts-dev-proxy.com (proxy-notebook.modelarts-dev-proxy.com)... 192.168.0.172\n",
      "Connecting to proxy-notebook.modelarts-dev-proxy.com (proxy-notebook.modelarts-dev-proxy.com)|192.168.0.172|:8083... connected.\n",
      "Proxy request sent, awaiting response... 200 OK\n",
      "Length: 10754903 (10M) [application/zip]\n",
      "Saving to: ‘MNIST_Data.zip’\n",
      "\n",
      "MNIST_Data.zip      100%[===================>]  10.26M  --.-KB/s    in 0.06s   \n",
      "\n",
      "2020-11-30 16:41:42 (185 MB/s) - ‘MNIST_Data.zip’ saved [10754903/10754903]\n",
      "\n",
      "Archive:  MNIST_Data.zip\n",
      "   creating: MNIST_Data/test/\n",
      "  inflating: MNIST_Data/test/t10k-images-idx3-ubyte  \n",
      "  inflating: MNIST_Data/test/t10k-labels-idx1-ubyte  \n",
      "   creating: MNIST_Data/train/\n",
      "  inflating: MNIST_Data/train/train-images-idx3-ubyte  \n",
      "  inflating: MNIST_Data/train/train-labels-idx1-ubyte  \n",
      "./datasets/MNIST_Data/\n",
      "├── test\n",
      "│   ├── t10k-images-idx3-ubyte\n",
      "│   └── t10k-labels-idx1-ubyte\n",
      "└── train\n",
      "    ├── train-images-idx3-ubyte\n",
      "    └── train-labels-idx1-ubyte\n",
      "\n",
      "2 directories, 4 files\n"
     ]
    }
   ],
   "source": [
    "!wget -N https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/datasets/MNIST_Data.zip\n",
    "!unzip -o MNIST_Data.zip -d ./datasets\n",
    "!tree ./datasets/MNIST_Data/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 处理MNIST数据集"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由于我们后面会采用LeNet这样的卷积神经网络对数据集进行训练，而采用LeNet在训练数据时，对数据格式是有所要求的，所以接下来的工作需要我们先查看数据集内的数据是什么样的，这样才能构造一个针对性的数据转换函数，将数据集数据转换成符合训练要求的数据形式。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 查看原始数据集数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-20T07:21:46.072389Z",
     "start_time": "2020-10-20T07:21:44.970964Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The type of mnist_ds: <class 'mindspore.dataset.engine.datasets.MnistDataset'>\n",
      "Number of pictures contained in the mnist_ds： 60000\n",
      "The item of mnist_ds: dict_keys(['image', 'label'])\n",
      "Tensor of image in item: (28, 28, 1)\n",
      "The label of item: 2\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from mindspore import context\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "import numpy as np\n",
    "import mindspore.dataset as ds\n",
    "\n",
    "context.set_context(mode=context.GRAPH_MODE, device_target=\"CPU\") \n",
    "train_data_path = \"./datasets/MNIST_Data/train\"\n",
    "test_data_path = \"./datasets/MNIST_Data/test\"\n",
    "mnist_ds = ds.MnistDataset(train_data_path)\n",
    "print('The type of mnist_ds:', type(mnist_ds))\n",
    "print(\"Number of pictures contained in the mnist_ds：\", mnist_ds.get_dataset_size())\n",
    "\n",
    "dic_ds = mnist_ds.create_dict_iterator()\n",
    "item = next(dic_ds)\n",
    "img = item[\"image\"].asnumpy()\n",
    "label = item[\"label\"].asnumpy()\n",
    "\n",
    "print(\"The item of mnist_ds:\", item.keys())\n",
    "print(\"Tensor of image in item:\", img.shape) \n",
    "print(\"The label of item:\", label)\n",
    "\n",
    "plt.imshow(np.squeeze(img))\n",
    "plt.title(\"number:%s\"% item[\"label\"].asnumpy())\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从上面的运行情况我们可以看到，训练数据集`train-images-idx3-ubyte`和`train-labels-idx1-ubyte`对应的是6万张图片和6万个数字下标，载入数据后经过`create_dict_iterator`转换字典型的数据集，取其中的一个数据查看，这是一个key为`image`和`label`的字典，其中的`image`的张量(高度28，宽度28，通道1)和`label`为对应图片的数字。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数据处理\n",
    "\n",
    "数据集对于训练非常重要，好的数据集可以有效提高训练精度和效率，在加载数据集前，我们通常会对数据集进行一些处理。\n",
    "\n",
    "#### 定义数据集及数据操作\n",
    "\n",
    "我们定义一个函数`create_dataset`来创建数据集。在这个函数中，我们定义好需要进行的数据增强和处理操作：\n",
    "\n",
    "1. 定义数据集。\n",
    "2. 定义进行数据增强和处理所需要的一些参数。\n",
    "3. 根据参数，生成对应的数据增强操作。\n",
    "4. 使用`map`映射函数，将数据操作应用到数据集。\n",
    "5. 对生成的数据集进行处理。\n",
    "\n",
    "定义完成后，使用`create_datasets`对原始数据进行增强操作，并抽取一个`batch`的数据，查看数据增强后的变化。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-20T07:21:46.091026Z",
     "start_time": "2020-10-20T07:21:46.073390Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of groups in the dataset: 1875\n"
     ]
    }
   ],
   "source": [
    "import mindspore.dataset.vision.c_transforms as CV\n",
    "import mindspore.dataset.transforms.c_transforms as C\n",
    "from mindspore.dataset.vision import Inter\n",
    "from mindspore import dtype as mstype\n",
    "\n",
    "\n",
    "def create_dataset(data_path, batch_size=32, repeat_size=1,\n",
    "                   num_parallel_workers=1):\n",
    "    \"\"\" \n",
    "    create dataset for train or test\n",
    "    \n",
    "    Args:\n",
    "        data_path (str): Data path\n",
    "        batch_size (int): The number of data records in each group\n",
    "        repeat_size (int): The number of replicated data records\n",
    "        num_parallel_workers (int): The number of parallel workers\n",
    "    \"\"\"\n",
    "    # define dataset\n",
    "    mnist_ds = ds.MnistDataset(data_path)\n",
    "\n",
    "    # define some parameters needed for data enhancement and rough justification\n",
    "    resize_height, resize_width = 32, 32\n",
    "    rescale = 1.0 / 255.0\n",
    "    shift = 0.0\n",
    "    rescale_nml = 1 / 0.3081\n",
    "    shift_nml = -1 * 0.1307 / 0.3081\n",
    "\n",
    "    # according to the parameters, generate the corresponding data enhancement method\n",
    "    resize_op = CV.Resize((resize_height, resize_width), interpolation=Inter.LINEAR)\n",
    "    rescale_nml_op = CV.Rescale(rescale_nml, shift_nml)\n",
    "    rescale_op = CV.Rescale(rescale, shift)\n",
    "    hwc2chw_op = CV.HWC2CHW()\n",
    "    type_cast_op = C.TypeCast(mstype.int32)\n",
    "\n",
    "    # using map to apply operations to a dataset\n",
    "    mnist_ds = mnist_ds.map(operations=type_cast_op, input_columns=\"label\", num_parallel_workers=num_parallel_workers)\n",
    "    mnist_ds = mnist_ds.map(operations=resize_op, input_columns=\"image\", num_parallel_workers=num_parallel_workers)\n",
    "    mnist_ds = mnist_ds.map(operations=rescale_op, input_columns=\"image\", num_parallel_workers=num_parallel_workers)\n",
    "    mnist_ds = mnist_ds.map(operations=rescale_nml_op, input_columns=\"image\", num_parallel_workers=num_parallel_workers)\n",
    "    mnist_ds = mnist_ds.map(operations=hwc2chw_op, input_columns=\"image\", num_parallel_workers=num_parallel_workers)\n",
    "    \n",
    "    # process the generated dataset\n",
    "    buffer_size = 10000\n",
    "    mnist_ds = mnist_ds.shuffle(buffer_size=buffer_size)\n",
    "    mnist_ds = mnist_ds.batch(batch_size, drop_remainder=True)\n",
    "    mnist_ds = mnist_ds.repeat(repeat_size)\n",
    "\n",
    "    return mnist_ds\n",
    "\n",
    "ms_dataset = create_dataset(train_data_path)\n",
    "print('Number of groups in the dataset:', ms_dataset.get_dataset_size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上述增强过程中：\n",
    "- 数据集中的`label`数据增强操作：\n",
    "    - `C.TypeCast`：对数据类型转化为`int32`。\n",
    "- 数据集中的`image`数据增强操作：\n",
    "    - `datasets.MnistDataset`：将数据集转化为MindSpore可训练的数据。 \n",
    "    - `CV.Resize`：对图像数据像素进行缩放，适应LeNet5网络对数据的尺寸要求。\n",
    "    - `CV.Rescale`：对图像数据进行标准化，归一化操作，使得每个像素的数值大小在范围（0,1）中，可以提升训练效率。\n",
    "    - `CV.HWC2CHW`：对图像数据张量进行变换，张量形式由高x宽x通道（HWC）变为通道x高x宽（CHW），方便进行数据训练。\n",
    "- 其他增强操作：\n",
    "    - `mnist_ds.shuffle`：本例中表示随机将数据存放在可容纳10000张图片地址的内存中进行混洗。\n",
    "    - `mnist_ds.batch`：本例中表示从混洗的10000张图片地址中抽取32张图片组成一个`batch`。\n",
    "    - `mnist_ds.repeat`：将`batch`数据进行复制增强。\n",
    "\n",
    "> 先进行`shuffle`、`batch`操作，再进行`repeat`操作，这样能保证1个`epoch`内数据不重复。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "调用数据增强函数后，查看数据集`size`由60000变成了1875，符合我们的数据增强中`mnist_ds.batch`操作的预期（$60000/32=1875$）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 进一步查看增强后的数据"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从1875组数据中取出一组数据查看其数据张量及`label`。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-20T07:21:46.521303Z",
     "start_time": "2020-10-20T07:21:46.092033Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor of image: (32, 1, 32, 32)\n",
      "labels: [1 9 6 9 4 1 0 3 3 7 7 1 7 5 7 4 7 3 0 8 5 3 3 9 6 3 7 8 2 3 8 1]\n"
     ]
    }
   ],
   "source": [
    "data = next(ms_dataset.create_dict_iterator(output_numpy=True))\n",
    "images = data[\"image\"]\n",
    "labels = data[\"label\"]\n",
    "print('Tensor of image:', images.shape)\n",
    "print('labels:', labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "将张量数据和下标对应的值进行可视化。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-20T07:21:47.141782Z",
     "start_time": "2020-10-20T07:21:46.522315Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 32 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "count = 1\n",
    "for i in images:\n",
    "    plt.subplot(4, 8, count) \n",
    "    plt.imshow(np.squeeze(i))\n",
    "    plt.title('num:%s'%labels[count-1])\n",
    "    plt.xticks([])\n",
    "    count += 1\n",
    "    plt.axis(\"off\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过上述查询操作，看到经过变换后的图片，数据集内分成了1875组数据，每组数据中含有32张图片，每张图片像数值为32×32，数据全部准备好后，就可以进行下一步的数据训练了。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 构造神经网络"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在对手写字体识别上，通常采用卷积神经网络架构（CNN）进行学习预测，最经典的属1998年由Yann LeCun创建的LeNet5架构，<br/>其中分为：<br/>1、输入层；<br/>2、卷积层C1；<br/>3、池化层S2；<br/>4、卷积层C3；<br/>5、池化层S4；<br/>6、全连接F6；<br/>7、全连接；<br/>8、全连接OUTPUT。<br/>结构示意如下图："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LeNet5结构图"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://gitee.com/mindspore/docs/raw/master/tutorials/training/source_zh_cn/quick_start/images/LeNet_5.jpg\" alt=\"LeNet5\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "更多的LeNet网络的介绍不在此赘述，希望详细了解LeNet网络，可以查询<http://yann.lecun.com/exdb/lenet/>。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在构建LeNet5前，我们需要对全连接层以及卷积层进行初始化。\n",
    "\n",
    "`Normal`：参数初始化方法，MindSpore支持`TruncatedNormal`、`Normal`、`Uniform`等多种参数初始化方法，具体可以参考MindSpore API的`mindspore.common.initializer`模块说明。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用MindSpore定义神经网络需要继承`mindspore.nn.Cell`，`Cell`是所有神经网络（`Conv2d`等）的基类。\n",
    "\n",
    "神经网络的各层需要预先在`__init__`方法中定义，然后通过定义`construct`方法来完成神经网络的前向构造，按照LeNet5的网络结构，定义网络各层如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-20T07:21:47.178650Z",
     "start_time": "2020-10-20T07:21:47.143316Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "layer conv1: Conv2d<input_channels=1, output_channels=6, kernel_size=(5, 5),stride=(1, 1),  pad_mode=valid, padding=0, dilation=(1, 1), group=1, has_bias=False,weight_init=normal, bias_init=zeros>\n",
      "****************************************\n",
      "layer fc1: Dense<in_channels=400, out_channels=120, weight=Parameter (name=fc1.weight, value=[[-0.00758117 -0.01498233  0.01308791 ...  0.03045311 -0.00079244\n",
      "  -0.01519072]\n",
      " [-0.00077699 -0.01607893 -0.00215094 ... -0.00235667 -0.01918699\n",
      "  -0.00828544]\n",
      " [-0.00105981 -0.01547002 -0.01332507 ...  0.01294748  0.00878882\n",
      "   0.01031067]\n",
      " ...\n",
      " [ 0.01414873 -0.02673322  0.01534838 ...  0.00437457 -0.01688845\n",
      "  -0.00188475]\n",
      " [ 0.01756713 -0.0201801  -0.0223504  ...  0.00682346 -0.00856738\n",
      "   0.00753205]\n",
      " [-0.01119993  0.01894077 -0.02048291 ...  0.03681218 -0.01461048\n",
      "   0.0045935 ]]), has_bias=True, bias=Parameter (name=fc1.bias, value=[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.])>\n"
     ]
    }
   ],
   "source": [
    "import mindspore.nn as nn\n",
    "from mindspore.common.initializer import Normal\n",
    "\n",
    "class LeNet5(nn.Cell):\n",
    "    \"\"\"Lenet network structure.\"\"\"\n",
    "    # define the operator required\n",
    "    def __init__(self, num_class=10, num_channel=1):\n",
    "        super(LeNet5, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(num_channel, 6, 5, pad_mode='valid')\n",
    "        self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid')\n",
    "        self.fc1 = nn.Dense(16 * 5 * 5, 120, weight_init=Normal(0.02))\n",
    "        self.fc2 = nn.Dense(120, 84, weight_init=Normal(0.02))\n",
    "        self.fc3 = nn.Dense(84, num_class, weight_init=Normal(0.02))\n",
    "        self.relu = nn.ReLU()\n",
    "        self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        self.flatten = nn.Flatten()\n",
    "\n",
    "    # use the preceding operators to construct networks\n",
    "    def construct(self, x):\n",
    "        x = self.max_pool2d(self.relu(self.conv1(x)))\n",
    "        x = self.max_pool2d(self.relu(self.conv2(x)))\n",
    "        x = self.flatten(x)\n",
    "        x = self.relu(self.fc1(x))\n",
    "        x = self.relu(self.fc2(x))\n",
    "        x = self.fc3(x) \n",
    "        return x\n",
    "    \n",
    "network = LeNet5()\n",
    "print(\"layer conv1:\", network.conv1)\n",
    "print(\"*\"*40)\n",
    "print(\"layer fc1:\", network.fc1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "构建完成后，可以使用`print(LeNet5())`将神经网络中的各层参数全部打印出来，也可以使用`LeNet().{layer名称}`打印相应的参数信息。本例选择打印第一个卷积层和第一个全连接层的相应参数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 自定义回调函数收集模型的损失值和精度值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "自定义一个收集每一步训练的`step`，每训练一个`step`模型对应的`loss`值，每训练25个`step`模型对应的验证精度值`acc`的类`StepLossAccInfo`，该类继承了`Callback`类，可以自定义训练过程中的处理措施，非常方便，等训练完成后，可将数据绘图查看`step`与`loss`的变化情况，step与acc的变化情况。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "参数解释如下：\n",
    "\n",
    "- `model`：函数的模型Model。\n",
    "- `eval_dataset`：验证数据集。\n",
    "- `step_loss`：收集step和loss值的字典，数据格式`{\"step\": [], \"loss_value\": []}`。\n",
    "- `steps_eval`：收集step和模型精度值的字典，数据格式为`{\"step\": [], \"acc\": []}`。\n",
    "\n",
    "以下代码在会作为回调函数，在模型训练函数`model.train`中调用，用于收集训练过程中step数和相对应的loss值、精度值等信息，最终使用收集到的信息，进行可视化展示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-20T07:21:47.246860Z",
     "start_time": "2020-10-20T07:21:47.180702Z"
    }
   },
   "outputs": [],
   "source": [
    "from mindspore.train.callback import Callback\n",
    "\n",
    "# custom callback function\n",
    "class StepLossAccInfo(Callback):\n",
    "    def __init__(self, model, eval_dataset, step_loss, steps_eval):\n",
    "        self.model = model\n",
    "        self.eval_dataset = eval_dataset\n",
    "        self.step_loss = step_loss\n",
    "        self.steps_eval = steps_eval\n",
    "        \n",
    "    def step_end(self, run_context):\n",
    "        cb_params = run_context.original_args()\n",
    "        cur_epoch = cb_params.cur_epoch_num\n",
    "        cur_step = (cur_epoch-1)*1875 + cb_params.cur_step_num\n",
    "        self.step_loss[\"loss_value\"].append(str(cb_params.net_outputs))\n",
    "        self.step_loss[\"step\"].append(str(cur_step))\n",
    "        if cur_step % 125 == 0:\n",
    "            acc = self.model.eval(self.eval_dataset, dataset_sink_mode=False)\n",
    "            self.steps_eval[\"step\"].append(cur_step)\n",
    "            self.steps_eval[\"acc\"].append(acc[\"Accuracy\"])\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 搭建训练网络并进行训练"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "构建完成神经网络后，就可以着手进行训练网络的构建，模型训练函数为`Model.train`，参数主要包含：\n",
    "1. 每个`epoch`需要遍历完成图片的`batch`数：`epoch_size`；\n",
    "2. 数据集`ds_train`；\n",
    "3. 回调函数`callbacks`包含`ModelCheckpoint`、`LossMonitor`和`Callback`模型检测参数；\n",
    "4. 数据下沉模式`dataset_sink_mode`，此参数默认`True`需设置成`False`，因为此功能不支持CPU模式。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义损失函数及优化器\n",
    "\n",
    "在进行定义之前，先简单介绍损失函数及优化器的概念。\n",
    "\n",
    "损失函数：又叫目标函数，用于衡量预测值与实际值差异的程度。深度学习通过不停地迭代来缩小损失函数的值。定义一个好的损失函数，可以有效提高模型的性能。\n",
    "\n",
    "优化器：用于最小化损失函数，从而在训练过程中改进模型。\n",
    "\n",
    "定义了损失函数后，可以得到损失函数关于权重的梯度。梯度用于指示优化器优化权重的方向，以提高模型性能。\n",
    "\n",
    "MindSpore支持的损失函数有`SoftmaxCrossEntropyWithLogits`、`L1Loss`、`MSELoss`等。这里使用`SoftmaxCrossEntropyWithLogits`损失函数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-20T07:22:17.681717Z",
     "start_time": "2020-10-20T07:21:47.248874Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 1 step: 125, loss is 2.3114552\n",
      "epoch: 1 step: 250, loss is 2.2977211\n",
      "epoch: 1 step: 375, loss is 2.2881548\n",
      "epoch: 1 step: 500, loss is 2.3017395\n",
      "epoch: 1 step: 625, loss is 2.28271\n",
      "epoch: 1 step: 750, loss is 2.2940521\n",
      "epoch: 1 step: 875, loss is 0.63723934\n",
      "epoch: 1 step: 1000, loss is 0.26923218\n",
      "epoch: 1 step: 1125, loss is 0.50213444\n",
      "epoch: 1 step: 1250, loss is 0.13894697\n",
      "epoch: 1 step: 1375, loss is 0.3275225\n",
      "epoch: 1 step: 1500, loss is 0.0130375605\n",
      "epoch: 1 step: 1625, loss is 0.061674632\n",
      "epoch: 1 step: 1750, loss is 0.098301426\n",
      "epoch: 1 step: 1875, loss is 0.033478882\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from mindspore import Tensor, Model\n",
    "from mindspore import load_checkpoint, load_param_into_net\n",
    "from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor\n",
    "from mindspore.nn.metrics import Accuracy\n",
    "from mindspore.nn.loss import SoftmaxCrossEntropyWithLogits\n",
    "\n",
    "lr = 0.01\n",
    "momentum = 0.9 \n",
    "epoch_size = 1\n",
    "mnist_path = \"./datasets/MNIST_Data\"\n",
    "model_path = \"./models/ckpt/mindspore_quick_start/\"\n",
    "\n",
    "# clean up old run files before in Linux\n",
    "os.system('rm -f {}*.ckpt {}*.meta {}*.pb'.format(model_path, model_path, model_path))\n",
    "\n",
    "# create the network\n",
    "network = LeNet5()\n",
    "\n",
    "# define the optimizer\n",
    "net_opt = nn.Momentum(network.trainable_params(), lr, momentum)\n",
    "\n",
    "# define the loss function\n",
    "net_loss = SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')\n",
    "\n",
    "# define the model\n",
    "model = Model(network, net_loss, net_opt, metrics={\"Accuracy\": Accuracy()} )\n",
    "\n",
    "# save the network model and parameters for subsequence fine-tuning\n",
    "config_ck = CheckpointConfig(save_checkpoint_steps=375, keep_checkpoint_max=16)\n",
    "# group layers into an object with training and evaluation features\n",
    "ckpoint_cb = ModelCheckpoint(prefix=\"checkpoint_lenet\", directory=model_path, config=config_ck)\n",
    "\n",
    "\n",
    "eval_dataset = create_dataset(\"./datasets/MNIST_Data/test\")\n",
    "\n",
    "step_loss = {\"step\": [], \"loss_value\": []}\n",
    "steps_eval = {\"step\": [], \"acc\": []}\n",
    "# collect the steps,loss and accuracy information\n",
    "step_loss_acc_info = StepLossAccInfo(model , eval_dataset, step_loss, steps_eval)\n",
    "\n",
    "repeat_size = 1\n",
    "ds_train = create_dataset(os.path.join(mnist_path, \"train\"), 32, repeat_size)\n",
    "\n",
    "model.train(epoch_size, ds_train, callbacks=[ckpoint_cb, LossMonitor(125), step_loss_acc_info], dataset_sink_mode=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "参数解释：\n",
    "\n",
    "`ModelCheckpoint`：模型保存函数，作为回调函数调用，用于设置保存模型的名称、路径、保存频次和保存模型的数量等信息。\n",
    "\n",
    "训练完成后，能在Jupyter的工作路径上生成多个模型文件，名称具体含义`checkpoint_{网络名称}-{第几个epoch}_{第几个step}.ckpt`。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 查看损失函数随着训练步数的变化情况"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-20T07:22:17.822724Z",
     "start_time": "2020-10-20T07:22:17.682710Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAEWCAYAAACEz/viAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAvqklEQVR4nO3debxd873/8dcng4ggCUnVEKJBNVRDUsMvqN6WoogaWm4voVrzLaq0KCWt1tBetKhLja25qmIeLoKQkpBEBkNiSkw5iUhCIuPn98d3bXudfdYez15773P2+/l47Mdae42fvc4+67O/3+9a32XujoiINLcu9Q5ARETqT8lARESUDERERMlARERQMhAREZQMREQEJQNpJzPraWb3mtkCM7uzxvueama71XKfhZjZQDNzM+tWw30eYWbP1Gp/1WZmu5nZ7HrHIUoGnYaZvWVm367Drg8C1gPWdfeD09qJmd1gZr+NT3P3rdz9ybT2KR1PPRJyZ6FkIO21CfCau6+odyDS3JQA2kfJoJMzsx5mdqmZvRe9LjWzHtG8fmZ2n5l9bGYfmdnTZtYlmvcLM3vXzBaZ2atm9q2EbZ8HnAP8wMw+MbOjzOxcM/t7bJlWv9TM7Ekz+42ZjY22/YiZ9Ystv7OZPRvFNCuqBjka+CFwerSfe6NlPy8NFfmcu5nZbDM71czmmNn7ZnZknuP1AzMbnzPtFDMbHY1/18xeMrOFUXznFjj2rUprCcdmx9hnnVSoysvMBpjZP82sxczmmdnlOfP/YGbzzexNM9srNv1IM5seHes3zOyY2LyCx8XM1o2qABea2Qtm9tt4lZSZbWlmj0bfnVfN7PsF4l/HzK6P/jbzzexfOfPzxZD3eMe+W0eZ2TvA48BT0eyPo+/KTvlikhzurlcneAFvAd9OmD4KGAd8AegPPAv8Jpr3e+AqoHv02gUw4MvALGCDaLmBwKA8+z0X+HuB9wMBB7pF758EZgJbAD2j9xdE8zYBFgGHRvGsCwyJ5t0A/DbfZy7yOXcDVkTLdAf2BhYDfRM+zxpRDJvHpr0AHBLb1lcJP6S2AT4E9s/zWVv9TeLHBtgQmBfF0gXYPXrfPyGmrsAk4BKgF7A6sHM07whgOfCTaLnjgPcAi+Z/FxgU/V2/EX3u7Uo5LsBt0WsNYDDhO/FMNK9X9P5IoBuwLTAXGJzne3I/cDvQN9rXN0qMoZTjfVMUT8/cv4Fepb9UMuj8fgiMcvc57t4CnAccFs1bDqwPbOLuy939aQ//ZSuBHsBgM+vu7m+5+8wqxnS9u7/m7kuAO4Ah0fT/BB5z91ujeOa5+8QSt1noc0L4rKOi7T4AfEJIeq24+2LgHkJCwsw2B7YERkfzn3T3l919lbtPBm4lnGTL9V/AA+7+QLStR4HxhJNhru2BDYDT3P1Td//M3eONxm+7+zXuvhK4kfA3XS+K9353n+nBGOARQtIveFzMrCtwIPBrd1/s7tOibWfsA7zl7te7+wp3fwm4C2jTbmRm6wN7Ace6+/xoX2OKxRDFX8rxPjc6LkuSDrSURsmg89sAeDv2/u1oGsDFwAzgkagK4ZcA7j4DOJnwS3aOmd1mZhtQPR/ExhcDa0bjAwilhkoU+pwA87x1u0Z8v7luIUoGhAT1ryhJYGY7mNkTUXXNAuBYoF+e7RSyCXBwVEX0sZl9DOxMOJHnGkA44edrl/n8eGbiJPpsZraXmY2LqnI+JiSbeLz5jkt/wi/+WbF58fFNgB1y4v8h8MU88X/k7vPzxJ/3b1Pi8Z6FtJuSQef3HuEfN2PjaBruvsjdT3X3LwH7AT+zqG3A3W9x952jdR24sMT9fUqoVshIOjnkM4tQpZGkWPe6eT9nBR4F+pvZEEJSuCU27xZCKWGAu/cmVLNZnu0UOhazgL+5e5/Yq5e7X5CwnVnAxlZmA2nUZnIX8AdgPXfvAzxQIN64FkL1zUaxaQNyYhqTE/+a7n5cnvjXMbM+5cQfKeV4e55xKYOSQefS3cxWj726EYrVvzKz/hYaas8B/g5gZvuY2WZmZsACQvXQKjP7spn9R3Qy+QxYAqwqMYaJwK5mtrGZ9QbOKCP+m4Fvm9n3zaxb1IA5JJr3IfClAuvm/ZzlcvflwJ2EktM6hOSQsRbhV+5nZrY9oeSQz0TgEDPrbmbDCJfhZvwd2NfMvmNmXaO/125mtlHCdp4H3gcuMLNe0bLDS/goqxGq+1qAFVHD8h4lrEdU5fRP4FwzW8PMtgQOjy1yH7CFmR0Wfb7uZvZ1M/tKwrbeBx4ErjSzvtGyu5YSB+UdbwifdRWFvyuSQMmgc3mAcOLOvM4Ffkuoi54MvAy8GE0D2Bx4jFBH+xxwpbs/QTiBXEBoEPyA0Chb0kk9qvu+PdrfBMJJoyTu/g6hGuNU4CPCyfRr0exrCW0YH+deiRIp9DkrcQvwbeDOnCqM44FRZraIkHDuKLCNswklnfmENozPSxjuPgsYAZxJOIHNAk4j4X8yOjHvC2wGvAPMBn5Q7AO4+yLgp1GM8wkn0tHF1os5EehN+A78jZBwl8a2vQdwCKEE9gGh9Ngjz7YOI7QNvALMIVRDlqKc452pJjsfGBt9V3YscT9NL3PFgYhIQWZ2IfBFdx9Z71ik+lQyEJFE0X0E21iwPXAUcHe945J06I49EclnLULV0AaENps/Ei67lU5I1UQiIqJqIhER6aDVRP369fOBAwfWOwwRkQ5lwoQJc929f9K8DpkMBg4cyPjx44svKCIinzOzt/PNUzWRiIgoGYiIiJKBiIigZCAiIigZiIgISgYiIoKSgYiIoGQgafn732HRonpHISIlUjKQ6pkzBz79FF54AQ47DEaqp2ORjkLJoKN46SU48URIq2PBadPg4YcrX/+jj2C99WDNNeG96GmTd98N994Ll10W3j/zDFx1VRifMgWefrr1NhYsCMN33oHRo2HhQhgzBnbZBZboWeciqXL3DvcaOnSop2bBAvcPPmg9raXF/ayz3KdMcd9gA/fbb3d/9dWw7Ny57k8+6X7aae6PP57dxty57g884L5iRdjewoXuK1eG4U03uU+Y4H7bbWHbL7/sPm9edn9vvOF+wAFh+kcfhe2FNOB++eXuzzzjvmqV+5w52elnneU+dmz2/QsvuN98c9jemWe6H3dcWGfBAvcTTnDfZRf3ESPcv/WtsI/Meu+95/7pp+6TJrn/+Mfuxx8f9rfffmH+3XeH4cUXu196qfuxx7ovW5ZdP99r/Pjs+J13Zse7dHEfMMB9113bLhd/bbml+9Zbu99/v/uYMe6ffBLiXL48fMbRo8Ny55zjfv316X0/RDowYLznOa92yC6shw0b5hX1TTR5MowdG34FZ359FrLrrvDUU5UF2ZFtsQW89lq9o2ifM86ATTeFn/yk3pGINAwzm+DuwxLnNVUyuOQS+NnPqh+QNK4O+P0WSUuhZNBcbQbHHx/qs198ER57LCSGLl3ghhugWzfYaSf4zW9g2DDYYQfYscCztPv0CcNCy+Q68EDYfvv2fIK2fvOb6m6vkVXyK98MrrsOpk+vfjwinUm++qNGfqXaZpArUyddzGefZZedNCnUZ8fbATKWLXM/6ST3mTPdTzkltBlkLFgQ6sIffji0OVx3XWhbOPVU9zffDOs+8URodwD3fv1CO0BLi/vixaFNwt199uywnrv71Knus2Zlt3/NNe5HHZWti+/Z0/2SS7LjL7+cXGf//e+3/hxJyxxzTNtpI0a0nfbUU+7z52fbITKvCy/Mju+/f3b89NOz+z3//NbrzJzZ+r1Z/nYLkSaH2gw6oWXLwimuR4/K1//4Y/jCF8L7Tz4Jv6J79YK33w5XBfXpAytWwKxZsNlmrdefNi0M+/QJ9fNXXhnWhdDe0NICI0aEX+T9o2dp7LtvuPfgySdbb+v55+H3v4c774RLL4UNNoCDDgpXEPXu3Tb2VavCq1vscRzusHJlmOYO99wDN94I//pX62VEmpjaDKQ5TZwI226bfT9lCmy1Vd3CEak3tRlIcxoyJJR+TjwxvN96a3j99XpGJNKwlAykc+vdG+bOzb5/8836xSLSwJQMpPO78sps9dBnn9U3FpEGpWQgnV/fvnDHHWF8woT6xiLSoJQMpDn07BmGo0bVNw6RBqVkIM2hX7/s+Pz59YtDpEEpGUhzWGut7Himd1QR+ZySgTSPP/0pDD/+uK5hiDQiJQNpHoMHh2H8UlMRAZQMpJlkOhfcfXdYurSuoYg0GiUDaR7xfo50v4FIK0oG0jxWXz07vnJl/eIQaUBKBtI8unfPji9bVr84RBqQkoE0j3gyWL68fnGINCAlA2keKhmI5KVkIM1DJQORvJQMpHnEn4ymZCDSipKBNI+uXbPjqiYSaSXVZGBmA8zsCTObZmZTzeykhGXMzP5kZjPMbLKZbZdmTNLEzLLjq1bVLw6RBtSt+CLtsgI41d1fNLO1gAlm9qi7T4stsxewefTaAfhLNBRJj5KBSCuplgzc/X13fzEaXwRMBzbMWWwEcJMH44A+ZrZ+mnFJE3vooTBUMhBppWZtBmY2ENgW+HfOrA2BWbH3s2mbMDCzo81svJmNb2lpSS1O6eS6RF953YEs0kpNkoGZrQncBZzs7gsr2Ya7X+3uw9x9WP/+/asboDSPTCOySgYiraSeDMysOyER3Ozu/0xY5F1gQOz9RtE0kerLlAyUDERaSftqIgOuBaa7+//kWWw0cHh0VdGOwAJ3fz/NuKSJqZpIJFHaVxMNBw4DXjazidG0M4GNAdz9KuABYG9gBrAYODLlmKSZ5VYTPfccbLMN9OpVv5hEGkCqycDdnwGsyDIOnJBmHCKfi5cMWlrg//0/2H9/uPvuuoYlUm+6A1maSyYZrFgBn3wSxl96qX7xiDQIJQNpLplqon33hbfeCuNd9G8gov8CaV7jxoWhkoGIkoE0mRUrsuPuYahkIKJkIE0m3nV1JhksXBg6sbv33vrEJNIAlAykucRLBm++GYYffhiGv/td7eMRaRBKBtJc4iWDa6+tXxwiDUbJQJrLF75Q7whEGpKSgTSXIUPqHYFIQ1IyEBERJQMREVEyEBERlAxERAQlAxERQclAJCtzR7JIE1IyEBERJQMREVEyEMmygg/lE+nUlAxERETJQORzakCWJqZkICIiSgYiIqJkIJKlBmRpYkoGIiKiZCDyOTUgSxNTMhARESUDERFRMhDJUgOyNDElA5EMtRlIE1MyEBERJQMREVEyEBERlAxEstSALE0s1WRgZteZ2Rwzm5Jn/m5mtsDMJkavc9KMR6SgceNg0aJ6RyFSF2mXDG4A9iyyzNPuPiR6jUo5HpHCbrml3hGI1EWqycDdnwI+SnMfIlWlqiJpUo3QZrCTmU0yswfNbKt8C5nZ0WY23szGt7S01DI+EZFOr97J4EVgE3f/GvBn4F/5FnT3q919mLsP69+/f63ik2ZzzDHw1lv1jkKk5uqaDNx9obt/Eo0/AHQ3s371jEmEn/+83hGI1FzJycDM1jCzs83smuj95ma2T3t2bmZfNAuVtGa2fRTPvPZsU6Td1G4gTahbGcteD0wAdorevwvcCdyXbwUzuxXYDehnZrOBXwPdAdz9KuAg4DgzWwEsAQ5xVwcxUmdd6l17KlJ75SSDQe7+AzM7FMDdF2d+1efj7ocWmX85cHkZMYikTyUDaULl/ARaZmY9AQcws0HA0lSiEqknlQykCZVTMvg18BAwwMxuBoYDR6QRlEhdKRlIEyo5Gbj7o2b2IrAjYMBJ7j43tchE6kXJQJpQycnAzHaNRjOdtww2s8xdxiKdh9oMpAmVU010Wmx8dWB7wtVF/1HViETqTSUDaULlVBPtG39vZgOAS6sdkEjqpk+Hr3wl/3wlA2lC7fnWzwYK/EeJNKgttyw8X9VE0oTKaTP4M9FlpYQkMoTQt5BI56KSgTShctoMxsfGVwC3uvvYKscjUn9KBtKEymkzuDHNQERqasoU2Hrr5HmqJpImVDQZmNnLZKuHWs0C3N23qXpUImlbf/3881QykCZUSsmgXT2TijSkQr/+VTKQJlQ0Gbj727UIRKRhdOkCzz4LY8fCaacVX16kEyjneQY7mtkLZvaJmS0zs5VmtjDN4ERSU+jXf5cuMHw4nH567eIRqbNyKkcvBw4FXgd6Aj8GrkgjKJHUFUsGIk2mrG+9u88Aurr7Sne/HtgznbBEUlYoGUyfXrs4RBpEOfcZLDaz1YCJZnYR8D51foaySCoeeqjeEYjUXDkn88Oi5U8EPgUGAAemEZRI6jIlg549YcWK+sYi0gDKKRkMBe5394XAeSnFI1IbmUdtd+0aXiJNrpySwb7Aa2b2NzPbx8zKSSQijSWTDHRPgQhQRjJw9yOBzYA7CVcVzTSzv6YVmEiqSk0Gq1alH4tIAyjr1727LzezBwndU/QE9idcYirSMZWSDHSpqTSBcm4628vMbiDcZ3Ag8FfgiynFJZKuzAm+f//Cy61cmX4sIg2gnJLB4cDtwDHuvjSleERqY+214ZprYI89Ci+naiJpEuV0YX1ooflm9py779T+kERq5Mcl1HCqZCBNopqVoatXcVsijUElA2kS1UwGSc88EOkYRo1Knv7OOyodSFPQZRIiAPvumzz9q1/NnyhEOpFqJgPdvSOd01NP1TsCkdSVc2lpLzPrEo1vYWb7mVn32CKHVT06kVopdL/BWmvVLg6ROimnZPAUsLqZbQg8Qjj535CZ6e5TqhuaSA15gSavXr1qF4dInZSTDMzdFwMHAFe6+8HAVumEJVJjha4a0h3I0gTKSgZmthPwQ+D+aJq6e5TOoVAyUGd20gTKSQYnA2cAd7v7VDP7EvBEoRXM7Dozm2NmiVVIFvzJzGaY2WQz266MeESqp733EyxfDgv1SHDpuMrptXSMu+/n7hdGDclz3f2nRVa7gcKPxtwL2Dx6HQ38pdR4RKqqUJtBKQ48EHr3rk4sInVQztVEt5jZ2mbWC5gCTDOz0wqt4+5PAR8VWGQEcJMH44A+ZrZ+qTGJVE0pJYN58+CTT5Ln3XtvdeMRqbFyqokGR0852x94ENiU9l9OuiEwK/Z+djStDTM72szGm9n4lpaWdu5WJEexksFOO0G/fvCVr9QmHpEaKycZdI/uK9gfGO3uy6lhFxTufrW7D3P3Yf2LdTssUq5iJYNx48Jw9uz0YxGpg3KSwf8CbwG9gKfMbBOgvS1m7wIDYu83iqaJ1FahZNCe9oRZs2D11WHy5Mq3IVID5TQg/8ndN3T3vaM6/reBb7Zz/6OBw6OrinYEFrj7++3cpkj5CiWDN96ofLujR8PSpXDVVZVvQ6QGSn6egZn1Bn4N7BpNGgOMAhYUWOdWYDegn5nNjtbvDuDuVwEPAHsDM4DFwJFlfwKRaiiUDDJVREkOPBCefTb//Mw9Cu29WkkkZeU86ew6wlVE34/eHwZcT7gjOVGxB+K4uwMnlBGDSDoqOVmvWgX//GfhZZQMpIMoJxkMcvcDY+/PM7OJVY5HpD4quens8ceLL5PpykLJQBpcOQ3IS8xs58wbMxsOLKl+SCJ1MHx4+eusWFF8GZUMpIMop2RwLHBT1HYAMB8YWf2QROpgjTWqsx335L6MlAykwZWcDNx9EvA1M1s7er/QzE4GdM2cSEZuMlDJQDqIsvvmdfeF0Z3IAD+rcjwiHUdSCSC37UHJQDqI9nbUrr59pXklJYNJk2DOnLbLKBlIg2tvMtA3XJrPKafA0KHJ84YNg623zr6vZjJYtgxOP11dZUsqirYZmNkikk/6BvSsekQije7SSwvPb2kJ3U9ss011k8GNN8LFF4ekUCwGkTIVTQburqeBi5Tra19r3ZhcjWSwfHkYLl3a/m2J5NDDXUUqVcrjMDPL3HRT9mTe3v2p/UFSoGQgUqlykgHAJZeE4ZQpld3xrGcxS4qUDEQqdcopxZeZOzc7/tFHMHEifPWrcP75YZp7aAMoh0oGkgIlA5FKTZlSeP7998Opp2bfu4fnGwA8/3wYXnQR9OgRHqlZjKqJJEVKBiJpmTUr/7zMCf1vfwvD90t4jIeSgaRIyUAkLV1y/r2STuKZE3wpbQhKBpIiJQORjHHjstU6W27Z/u3lNvjGT+KffBKG5XRxrQZkSZGSgUjGDjvAWWfBdtvBH/7Q/u0VOnmPGQPTp5dXMshQyUBSoGQgEte3L0yYAJtt1v5tFSoZAEybVlnJQMlAUqBkIJKWYtU6Z55ZXsmgHk9NO+YYOOOM2u1P6kbJQCQtSQ3I8QTx2muVlQxKrVKaOTN7tVKlrr4aLrigfduQDkHJQKSWck/6lVxNVKqvfx0OP7y8daRpKRmIpOXII4svU0nVT6nLzp9f+jal6SkZiCTp3bv4MuXSfQbSwJQMRJJ88Yu12U85J3glA0mRkoFIPoMGVXd7uQ3IULyaaOVKuPfe5HXL2a9IEUoGIvWUSQb5qokuugj22w9Gj85OK/fkXo1k8Nln7d+GNDQlA5FacW97Yi6WDF59NQw/+qjyaqJqJIOePcNNctJpKRmI5FPtvoCSeiYt1oCcecRljx71bzOYNKk++5WaUDIQqZU77mj73IJibQZJyeC228L4okWl7VdtBlICJQORfEaOrP42H3209ftKSgYZ771X2j6rnQyWLYM//jE803mddeBb36ru9hvNKafA00/XO4rUKRmI5HPWWdXf5i23tH5frGSwfHkYdu/e9mE5pVZjVTsZ/PGP8POfw//+b7ix7fHHq7v9VavgpptgxYrqbrdSl14Ku+5a7yhSp2Qgkk8tnh9QrGSQOZFPmACnn568bjFJyWDOHDjvvPK6zs74+OMwzDyTodpuvDGUyi65pPJtuMNbb1UtpGagZCBST6V2R/Haa22nlZoMLrkEHnus9bRjjoFzz4UnnyxtG3GZWNNKlnPnhuGcOZVv489/hk03hRdfrE5MTSD1ZGBme5rZq2Y2w8x+mTD/CDNrMbOJ0evHacck0jAeeigMi5UMunVrO+/KK0vbxxlnwO67w803Z6dl7huI3z8we3Zpl4+mnQxy91OJZ54Jw9dfr18MHUyqycDMugJXAHsBg4FDzWxwwqK3u/uQ6PXXNGMSaUi5J50DDoCDD86+79q17TrlVqP89rfZ8e7dwzDTJjFtGgwYAFttVXqsaSWDamy3WpfhVjMZJN1n0kDSLhlsD8xw9zfcfRlwGzAi5X2KdDzxksGzz8Ldd8M//pE9eeQ+GyHXTTeF9QqJn2QzySDTSPuNb2Tnvf566Po6kyhy1apkUMzy5XDPPYU7AGzvybeSNpV8dt+9+N+xjtKObEMgfgnE7GhargPNbLKZ/cPMBiRtyMyONrPxZja+paUljVhF6mfVqnDimjUrW8UB2St1kkoGcSNHwvDh4QR56KHwyittl4mfiDLVTpkTfry6aOTI8FCc559P3lejJIPf/Ab23z9b1RbXiCWD//u/6m0rBY2Qpu4FBrr7NsCjwI1JC7n71e4+zN2H9e/fv6YBiqQu89SzjTeGF15oO7/UX5QjR4ab0n70o7bz4ifv3GQQP+kVK400SjLIXC2U1NCclAzmzYM33yxvH9UsGTS4tJPBu0D8l/5G0bTPufs8d4/urOGvwNCUYxKp3LHHprPdX/wiOz5jRtv5pZ54b701DJMuqyxUTRQ/aWZOgJUmg0WL4MMPSwq3XQr9+k+at9lm8KUvlbeP+PrV/EwN2H6QdjJ4AdjczDY1s9WAQ4DR8QXMbP3Y2/2A6SnHJFK5v/wl/X0kVQn96U/lbaNQP0jxfaxcGYbxE1O+6qGMYsngq1+tzfMgMvufOLF11Vp8XvxzZe6PKOckHC8ZnHRSuREmW7o0JNqzz67O9qok1WTg7iuAE4GHCSf5O9x9qpmNMrP9osV+amZTzWwS8FPgiDRjEml4EyaUvuwVV5Tem2j8l37uibySx26OHZs8/+23s+OLF5e+3XJlPsNll8EuuyTPS/pcV19d+j6Sqs/K9f77rav+Msfkiisq215KUm8zcPcH3H0Ldx/k7udH085x99HR+BnuvpW7f83dv+nuCS1fIpLoxBNh221LWzbpl/x998G665b3vILMSfEf/yi83KRJ0KtXuNLpv/+7/DuWi518C1Wd5SaD22/PzrvrrtJjqEabweDBsP32bacnfb6WllCymjy59L6nqqQRGpBFpD2WLSttuaQT2z33hGclJMl3si31F/Lvfx+GI0fC5ZfDH/5Q2nq5+120KLmEUahRPTcZHHJIafvO3W/8mMU/90UXhX2UkkQz1VNJsS1c2HreHXfAlCnwta/BhkkXXqZHyUCkWVSr47dSk0H81zhU/it77bVh4MC208spGZS6XsacOWG/55+fPP/ii8Mw92RejoULoXfvwt1ulNpNeRUoGYgUsuOO8J3vwCOPwPjx9Y6mfaZOLf3XbCG5Pa/WQtK9RYVO6oWeIFdKMss0wGdO+gB33tl2+9W4Iije2J+7vfjf6pvfhK98pf37yyOhwxMR+dxzz9U7guqbNy/bGVwh+U62udUeparlfQmZfd1wAxx1VHnrnnwyrLZaaduvpLSTexzMQhL44IO2y8a3X0mngmVQyUCk2Rx+eGgrqKYlS8JJLXOfQzXccw9stFH++aW0GeReclqKyy5rXSIotO9CJYOlS5PvTUha59prYYMN2vayWsN7EZQMRJpNqQ+jKedX77vRvaS/+lX58eQzc2Z2uxDurI4rVNKYOrX0/QweDDvvXF5spXR38b3vJd9vkbTOE0+E4fSc26xqeAe0koGIJMs9Ea1aBccdl7xsKV1UvPtueERmpdVMuZeyFtrXuHH55+WejKdPD/dMPP9828eSFjN/Ptx/f3JV1IMPJq+Te1wLfQ6VDEQaWNKdqNdeW/s40pZ70powAa66KnnZUpLBtdeGUsmVV+a/5+CSS2D06OR5uSfGardB7LAD7LFHactm7gE45hjYZx+47rrS91PoBJ87TyUDkQbWo0fbab16tX6f4lUfNZPpqiKj0PMTvvzlMCzlBH3WWbDWWuGX89NPt75j+Wc/g6eeSl4v90TZCN1Bz5uXPL2cEz7kP25KBiINrJQTXjXrzuul0itlkp7KlmTvvcOD5gcNKm1/pZYMSqlacU/3RJvvWRCZfefKPIUu97LfTJy5iTkFSgYilYo/iSxXvbt3roZKTkCZyyQr2U+hEygUP3nvvntpy7nD0UcXf0ZEKd55J3l6oRgKJbVJk9puZ6edSk+w7aBkIFKuzD/vttsmVxlBY1RhtFelJYNKf3EXSz7FSgaPPZa8XK4lS+CvVXq67pIlydPLSQaFDB9evBfZKukE31iROinUJ30zJ4NKFesuo9Q2g2Jxxx8Pmlb1S6Ht5n6OQh34Jd2IlpJO8I0VqbGka8wbsXGzvSo5UU6fXtnlkH/+c/FkUMolmW+8Ud7+ly4tvkxuDAsWJM9LekBQktz7PCrpRC8FneAbK1JjSSeh3H/+atRH19vPf167ff30p8WTz6efhruSx4wJVyEl/R0GDWp7cp05M/82y+2n6YILoE+f5Hnx70Chz/Jf/9X6ffxqqjpSMhCpVLyaKPek8t3vwvHH1z6masq9GzZtxUoGY8bA/vvDbruFq5DyVUn961+t32+2Wf5tlnuT2eWX558XTwYd8NnJSgYi5UqqJsptSOzePTzJ6tvfrl1cHV2+5yrkU40rtsqtosn0MLrFFm3nxb8PNbgUtNqUDETKdeyxsM02oQuCzAkg31Ulub9SJb+tty5v+XpevpvU1vDHP4bh3Lm1eQZ0lSkZiJRro43C9eAbbJCd9r3vhcdH5sq9M1mqp1jPomlKerrcmWeG4Ssd88m9SgYi1bDRRvmfEVDo5jTpmOIPpMnVu3ft4qgiJQOR9iilg7bcrpchXEopnVMHbC8AJQOR6sgkgzvugLvuaj2vS5dwFUr8QSvDhxd/mlY1bb11dR88I8lWrsz2aNrBKBmItEduyeDgg+GAA9oud8IJIQH07Jmd9sorcO+9xfcR7zrhnHMqi7NLl/AMXUnXJpuEy4rT9PLLqWxWyUCkGkq9smXDDcOwWzfYdNPQF/5aaxVep2/fMPze9+C88yqLz71z3AjX6OJPZktLStVQSgYi7TFsWHnLZy5BjTcyFuutM6M9T71ataomPV9KDeTrHLGd9O0QaY+HHgrVPaX+6l68OAzjl5zmu/P2jjvCQ3K22CLc05CvVLDuuvkfspKxapVKBp1FSnc3q2Qg0h59+4b+5kv14INw5JGwzjrZafmSwcEHh4bf1VYL7QaZKqa4++6DrbYqvl+VDFor1K1EoyvWbUeFlAxEammHHcLzcuNtDKuv3nqZSZNg1qzi2zrrrNBYmekhddttw3aTHk/Z3pLB2LGVr9uIDjqo3hFUTslApJMaPrz1+222CTex5XP66WGYOblnEsvFF4eT/sknt12nvckgqVSy7baVb6+eHnsM1luv3lFUrtQ2pjIpGYjU2113wcMPl758piSRKREkdZyXa9Wq8p+xMGFCNgl07Rq6mU7DCSeks9181lijtvurNpUMRDqp3r1hjz3gjDNKuzM58ws/c1VJvmQwfDi8+WYYX7WqvI7d+vaF7bbLXsbYpQtcdlnYxzXXtN5vPnvuWdoVUOXW3w8YUN7yuTJxd9TnVKeUDNSiJNIofve70pY79VRYuBBOOim8T0oGr70G66+f7Ra62BUor74aGrYzj4Ts3r31evFSRb7qoa22gqlTS/sMlerXL9yoN2RI+7fVnkt16ympk7wqUMlApKPp1Qv+8Ifs3cxrrx2G8auFNt8c1lwzexLPnNTHjoXZs0O7wi9/mV1+iy1Cd9snnRRKKE880Xq9eDIYNCgMTzklO23ZMpgypXWcmQ76brgBnnsu+bMUep7Affe1nTZiBGy5Zf51ch12WNtp8bvAIZSASikl5HYzUkypce68c3nbnT+/vOVL5e6pvoA9gVeBGcAvE+b3AG6P5v8bGFhsm0OHDnURicyd6z5qlPvKlW3nLV4cnsd28cVt5336aeZZbfm3ffbZYf6SJcnzM+tn9n399fm3GZ/+9tsh7owrrsjOB/cuXdwnTWo9Ddx/9KOw/Prrt57etWvbZUeMcF+40H3GjNbTX3stbOO448L7O+9079Wr7frxbX/96+4LFuRfJul17bWlLTdiROv3J5xQePnLLsv/9yoCGO95zquplgzMrCtwBbAXMBg41MwG5yx2FDDf3TcDLgEuTDMmkU5n3XXh7LOTG4h79gynkKTnGa+xBnzwAbz4Yv5tn3deaDfIvfw145FH4Ac/yO77iCNCKeCll5KXHzo0DDfeuPXzH44/PsSZqZ7q0SN7l/aJJ4ZLciHbXpLb/09mvbi//CV09TFoUOu2mEwD8pVXwvjxcOCB4YFFSX7723D1zvPPhxLYAw8kL5ckqSPCTTdtOz+3VLL++oW3+53vlB5DOfJliWq8gJ2Ah2PvzwDOyFnmYWCnaLwbMBewQttVyUCkA3rzTfdFiwovM3Vq+PW74Ybh/SuvuK9Y4f7ZZ+7HH58tTYwa1frX8t57u7/xhvtLL4X3F17Ydts/+Un+Us6qVe6jR4f5s2e7X3qp+5Ah7i0tbZe95pqw3JprhuF772XjmDYtDI891n35cvfvfKd1nO7ZEsnee4fhaae5X321+69+5T5wYPgckI03Pn7++aUe7UQUKBlYmJ8OMzsI2NPdfxy9PwzYwd1PjC0zJVpmdvR+ZrTM3JxtHQ0cDbDxxhsPffvtt1OLW0Tq6IILwq/1zTfPv8zy5aG7jv/8T5g2DQYOzHbxMWcO9O+f7tVC770XHm2ZKRFNnhz2me9X/ZVXhn6stt8+vH/66XDn+ujR4UqyNddsvfyyZaG0M2NG6Pxu113LvzQ4gZlNcPfEDrU6TDKIGzZsmI8fPz61uEVEOqNCySDtq4neBeIXBW8UTUtcxsy6Ab2BIr1uiYhINaWdDF4ANjezTc1sNeAQYHTOMqOBkdH4QcDjnmZxRURE2kj1pjN3X2FmJxIaibsC17n7VDMbRWjIGA1cC/zNzGYAHxEShoiI1FDqdyC7+wPAAznTzomNfwYcnHYcIiKSn+5AFhERJQMREVEyEBERlAxERISUbzpLi5m1AJXegtyP0OVFI2v0GBs9PlCM1dDo8UHjx9ho8W3i7v2TZnTIZNAeZjY+3x14jaLRY2z0+EAxVkOjxweNH2OjxxenaiIREVEyEBGR5kwGV9c7gBI0eoyNHh8oxmpo9Pig8WNs9Pg+13RtBiIi0lYzlgxERCSHkoGIiDRXMjCzPc3sVTObYWa/rFMMA8zsCTObZmZTzeykaPq5ZvaumU2MXnvH1jkjivlVM0vpAaht4nzLzF6OYhkfTVvHzB41s9ejYd9oupnZn6IYJ5vZdinH9uXYcZpoZgvN7OR6H0Mzu87M5kQPbMpMK/uYmdnIaPnXzWxk0r6qHOPFZvZKFMfdZtYnmj7QzJbEjudVsXWGRt+PGdHnqMpjxfLEV/bfNc3/9Twx3h6L7y0zmxhNr/kxrFi+52F2thehC+2ZwJeA1YBJwOA6xLE+sF00vhbwGjAYOBf4ecLyg6NYewCbRp+haw3ifAvolzPtIuCX0fgvgQuj8b2BBwEDdgT+XeO/6wfAJvU+hsCuwHbAlEqPGbAO8EY07BuN9005xj2AbtH4hbEYB8aXy9nO81HcFn2OvVKMr6y/a9r/60kx5sz/I3BOvY5hpa9mKhlsD8xw9zfcfRlwGzCi1kG4+/vu/mI0vgiYDmxYYJURwG3uvtTd3wRmED5LPYwAbozGbwT2j02/yYNxQB8zy/Mw2Kr7FjDT3QvdkV6TY+juTxGeyZG773KO2XeAR939I3efDzwK7JlmjO7+iLuviN6OIzyRMK8ozrXdfZyHs9pNsc9V9fgKyPd3TfV/vVCM0a/77wO3FtpGmsewUs2UDDYEZsXez6bwSTh1ZjYQ2Bb4dzTpxKiofl2mOoH6xe3AI2Y2wcyOjqat5+7vR+MfAOvVOUYID0OK/+M10jGE8o9Zvb+nPyL8Ss3Y1MxeMrMxZrZLNG3DKK6MWsRYzt+1nsdwF+BDd389Nq1RjmFBzZQMGoqZrQncBZzs7guBvwCDgCHA+4SiZj3t7O7bAXsBJ5jZrvGZ0a+Zul6XbOFRqvsBd0aTGu0YttIIx6wQMzsLWAHcHE16H9jY3bcFfgbcYmZr1yG0hv675jiU1j9OGuUYFtVMyeBdYEDs/UbRtJozs+6ERHCzu/8TwN0/dPeV7r4KuIZsNUZd4nb3d6PhHODuKJ4PM9U/0XBOPWMkJKoX3f3DKNaGOoaRco9ZXWI1syOAfYAfRkmLqPplXjQ+gVAPv0UUT7wqKdUYK/i71usYdgMOAG7PTGuUY1iKZkoGLwCbm9mm0S/KQ4DRtQ4iqlO8Fpju7v8Tmx6vY/8ekLlSYTRwiJn1MLNNgc0JDU9pxtjLzNbKjBMaGKdEsWSubhkJ3BOL8fDoCpkdgQWxqpE0tfoV1kjHMKbcY/YwsIeZ9Y2qQ/aIpqXGzPYETgf2c/fFsen9zaxrNP4lwnF7I4pzoZntGH2fD499rjTiK/fvWq//9W8Dr7j759U/jXIMS1LP1utavwhXcLxGyM5n1SmGnQlVBZOBidFrb+BvwMvR9NHA+rF1zopifpUaXHFAuApjUvSamjlWwLrA/wGvA48B60TTDbgiivFlYFgNYuwFzAN6x6bV9RgSEtP7wHJCHfBRlRwzQr39jOh1ZA1inEGoY898H6+Klj0w+vtPBF4E9o1tZxjhpDwTuJyoN4OU4iv775rm/3pSjNH0G4Bjc5at+TGs9KXuKEREpKmqiUREJA8lAxERUTIQERElAxERQclARERQMhApyMzOstC77OSo18kdLPSQuka9YxOpJl1aKpKHme0E/A+wm7svNbN+hF4wnyXcFzC3rgGKVJFKBiL5rQ/MdfelANHJ/yBgA+AJM3sCwMz2MLPnzOxFM7sz6ncq80yIi6I+6583s82i6Qeb2RQzm2RmT9Xno4m0ppKBSB7RSf0ZYA3C3cO3u/sYM3uLqGQQlRb+Sbj79VMz+wXQw91HRctd4+7nm9nhwPfdfR8zexnY093fNbM+7v5xPT6fSJxKBiJ5uPsnwFDgaKAFuD3q0C1uR8JDVsZaeLrVSMKDdjJujQ13isbHAjeY2U8ID2IRqbtu9Q5ApJG5+0rgSeDJ6Bd97mMojfAwmkPzbSJ33N2PNbMdgO8CE8xsqEc9W4rUi0oGInlYeNby5rFJQ4C3gUWER5ZCeDLY8Fh7QC8z2yK2zg9iw+eiZQa5+7/d/RxCiSPe3bJIXahkIJLfmsCfLTwgfgWhd8+jCV1nP2Rm77n7N6Oqo1vNrEe03q8IPWYC9DWzycDSaD2Ai6MkY4QeTSfV4sOIFKIGZJGUxBua6x2LSDGqJhIREZUMREREJQMREUHJQEREUDIQERGUDEREBCUDEREB/j+k/AEHytipIQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "steps = step_loss[\"step\"]\n",
    "loss_value = step_loss[\"loss_value\"]\n",
    "steps = list(map(int, steps))\n",
    "loss_value = list(map(float, loss_value))\n",
    "plt.plot(steps, loss_value, color=\"red\")\n",
    "plt.xlabel(\"Steps\")\n",
    "plt.ylabel(\"Loss_value\")\n",
    "plt.title(\"Loss function value change chart\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从上面可以看出来大致分为三个阶段：\n",
    "\n",
    "阶段一：开始训练loss值在2.2上下浮动，训练收益感觉并不明显。\n",
    "\n",
    "阶段二：训练到某一时刻，loss值减少迅速，训练收益大幅增加。\n",
    "\n",
    "阶段三：loss值收敛到一定小的值后，loss值开始振荡在一个小的区间上无法趋0，再继续增加训练并无明显收益，至此训练结束。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  测试数据验证模型精度"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "搭建测试网络的过程主要为：\n",
    "\n",
    "1. 载入模型`.ckpt`文件中的参数`param`；\n",
    "2. 将参数`param`载入到神经网络LeNet5中；\n",
    "3. 载入测试数据集；\n",
    "4. 调用函数`model.eval`传入参数测试数据集`ds_eval`，就生成模型`checkpoint_lenet-{epoch}_1875.ckpt`的精度值。\n",
    "\n",
    "> `dataset_sink_mode`表示数据集下沉模式，不支持CPU，所以这里设置成`False`。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-20T07:22:18.826530Z",
     "start_time": "2020-10-20T07:22:17.823755Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============== Starting Testing ==============\n",
      "============== Accuracy:{'Accuracy': 0.9669471153846154} ==============\n"
     ]
    }
   ],
   "source": [
    "# testing relate modules \n",
    "def test_net(network, model, mnist_path):\n",
    "    \"\"\"Define the evaluation method.\"\"\"\n",
    "    print(\"============== Starting Testing ==============\")\n",
    "    # load the saved model for evaluation\n",
    "    param_dict = load_checkpoint(\"./models/ckpt/mindspore_quick_start/checkpoint_lenet-1_1875.ckpt\")\n",
    "    # load parameter to the network\n",
    "    load_param_into_net(network, param_dict)\n",
    "    # load testing dataset\n",
    "    ds_eval = create_dataset(os.path.join(mnist_path, \"test\"))\n",
    "    acc = model.eval(ds_eval, dataset_sink_mode=False)\n",
    "    print(\"============== Accuracy:{} ==============\".format(acc))\n",
    "\n",
    "test_net(network, model, mnist_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "经过1875步训练后生成的模型精度超过95%，模型优良。\n",
    "我们可以看一下模型随着训练步数变化，精度随之变化的情况。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`eval_show`将绘制每25个`step`与模型精度值的折线图，其中`steps_eval`存储着模型的step数和对应模型精度值信息。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-20T07:22:18.957514Z",
     "start_time": "2020-10-20T07:22:18.828056Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def eval_show(steps_eval):\n",
    "    plt.xlabel(\"step number\")\n",
    "    plt.ylabel(\"Model accuracy\")\n",
    "    plt.title(\"Model accuracy variation chart\")\n",
    "    plt.plot(steps_eval[\"step\"], steps_eval[\"acc\"], \"red\")\n",
    "    plt.show()\n",
    "\n",
    "eval_show(steps_eval)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从图中可以看出训练得到的模型精度变化分为三个阶段：1、缓慢上升，2、迅速上升，3、缓慢上升趋近于不到1的某个值时附近振荡，说明随着训练数据的增加，会对模型精度有着正相关的影响，但是随着精度到达一定程度，训练收益会降低。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 模型预测应用"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们尝试使用生成的模型应用到分类预测单个或者单组图片数据上，具体步骤如下："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. 需要将要测试的数据转换成适应LeNet5的数据类型。\n",
    "2. 提取出`image`的数据。\n",
    "3. 使用函数`model.predict`预测`image`对应的数字。需要说明的是`predict`返回的是`image`对应0-9的概率值。\n",
    "4. 调用`plot_pie`将预测的各数字的概率显示出来。负概率的数字会被去掉。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "载入要测试的数据集并调用`create_dataset`转换成符合格式要求的数据集，并选取其中一组32张图片进行预测。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-20T07:22:19.982078Z",
     "start_time": "2020-10-20T07:22:18.958520Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Row 3, column 8 is incorrectly identified as 7, the correct value should be 9 \n",
      "\n",
      "Row 4, column 1 is incorrectly identified as 6, the correct value should be 5 \n",
      "\n",
      "[1 7 0 5 0 2 8 4 6 2 3 0 3 1 3 4 5 3 9 6 6 2 1 7 6 6 6 4 4 3 0 7] <--Predicted figures\n",
      "[1 7 0 5 0 2 8 4 6 2 3 0 3 1 3 4 5 3 9 6 6 2 1 9 5 6 6 4 4 3 0 7] <--The right number\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 32 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ds_test = create_dataset(test_data_path).create_dict_iterator()\n",
    "data = next(ds_test)\n",
    "images = data[\"image\"].asnumpy()\n",
    "labels = data[\"label\"].asnumpy()\n",
    "\n",
    "output = model.predict(Tensor(data['image']))\n",
    "prb = output.asnumpy()\n",
    "pred = np.argmax(output.asnumpy(), axis=1)\n",
    "err_num = []\n",
    "index = 1\n",
    "for i in range(len(labels)):\n",
    "    plt.subplot(4, 8, i+1)\n",
    "    color = 'blue' if pred[i] == labels[i] else 'red'\n",
    "    plt.title(\"pre:{}\".format(pred[i]), color=color)\n",
    "    plt.imshow(np.squeeze(images[i]))\n",
    "    plt.axis(\"off\")\n",
    "    if color == 'red':\n",
    "        index = 0\n",
    "        print(\"Row {}, column {} is incorrectly identified as {}, the correct value should be {}\".format(int(i/8)+1, i%8+1, pred[i], labels[i]), '\\n')\n",
    "if index:\n",
    "    print(\"All the figures in this group are predicted correctly!\")\n",
    "print(pred, \"<--Predicted figures\") \n",
    "print(labels, \"<--The right number\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "构建一个概率分析的饼图函数，本例展示了当前`batch`中的前两张图片的分析饼图。\n",
    "\n",
    "备注：`prb`为上一段代码中，存储这组数对应的数字概率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-20T07:22:20.152090Z",
     "start_time": "2020-10-20T07:22:19.983089Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Figure 1 probability of corresponding numbers [0-9]:\n",
      " [-5.7945986   9.7789135   0.3184681  -2.5145538   1.3727839  -1.8544098\n",
      " -0.9416619  -0.27712426  0.5978755  -1.4200687 ]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Figure 2 probability of corresponding numbers [0-9]:\n",
      " [-3.5296674  -1.4443045   0.55674577  1.7184858  -1.1003444  -3.0241313\n",
      " -7.969389   13.011139    0.46949214  1.3961829 ]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# define the pie drawing function of probability analysis\n",
    "def plot_pie(prbs):\n",
    "    dict1 = {}\n",
    "    # remove the negative number and build the dictionary dict1. The key is the number and the value is the probability value\n",
    "    for i in range(10):\n",
    "        if prbs[i] > 0:\n",
    "            dict1[str(i)] = prbs[i]\n",
    "\n",
    "    label_list = dict1.keys()\n",
    "    size = dict1.values()\n",
    "    colors = [\"red\", \"green\", \"pink\", \"blue\", \"purple\", \"orange\", \"gray\"] \n",
    "    color = colors[: len(size)]\n",
    "    plt.pie(size, colors=color, labels=label_list, labeldistance=1.1, autopct=\"%1.1f%%\", shadow=False, startangle=90, pctdistance=0.6)\n",
    "    plt.axis(\"equal\")\n",
    "    plt.legend()\n",
    "    plt.title(\"Image classification\")\n",
    "    plt.show()\n",
    "    \n",
    "    \n",
    "for i in range(2):\n",
    "    print(\"Figure {} probability of corresponding numbers [0-9]:\\n\".format(i+1), prb[i])\n",
    "    plot_pie(prb[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上过程就是这次手写数字分类训练的全部体验过程。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "MindSpore-1.0.1",
   "language": "python",
   "name": "mindspore-1.0.1"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}